package com.redpixy.monit.common.util;

/*
 * KDZZgame
 *
 * @(#)BattleManager.java      @(#)Create on :2009-6-28
 * 
 * Copyright (c) 2010 RedPixy, Inc. All rights reserved.
 * This SOURCE CODE FILE, which has been provided by RedPixy Software as part of 
 * a RedPixy Software product for use ONLY by licensed users of the product, includes
 * CONFIDENTIAL and PROPRIETARY information of RedPixy Software.
 * For more information please visit <http://www.redpixy.com/>.
 * 
 */


import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

import org.apache.log4j.Logger;
/**
 * 
 * @author ZhangLei.
 * @version 2009-6-28
 * 
 * @category 日期工具
 *
 */
public class DateUtil {

	private final static Logger logger = Logger.getLogger(DateUtil.class);

	/**
	 * 日期分隔符
	 */
	private final static String DATE_SPLIT_SIGN = "-";
	/**
	 * 时间分隔符
	 */
	private final static String TIME_SPLIT_SIGN = ":";
	/**
	 * 天(毫秒数)
	 */
	public final static long DAY =1000*60*60*24;
	/**
	 * UTC日期格式
	 */
	private final static SimpleDateFormat UTC_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSSSSS");
	/**
	 * 日期格式
	 */
	private static String format = "yyyy-MM-dd HH:mm:ss";
	private DateUtil(){}

	/**
	 * 得到当前日期 yyyy-MM-dd HH:mm:ss
	 * 
	 * @return yyyy-MM-dd HH:mm:ss
	 */
	public static String getNowString() {
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		Date now = new Date();
		return sdf.format(now);
	}

	/**
	 * 按指定的时间位,得到指定时间位后的时间
	 * @param sort
	 * @param num
	 * @return
	 */
	public static long getDateString(String sort, int num) {
		Date now = new Date();
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(now);
		if (sort.equals("SSS")) {

		} else if (sort.equals("ss")) {
			calendar.add(Calendar.SECOND, num);
		} else if (sort.equals("mm")) {

		} else if (sort.equals("HH")) {

		} else if (sort.equals("dd")) {

		} else if (sort.equals("MM")) {

		}
		return calendar.getTimeInMillis()/1000;
	}
	/**
	 * 返回当前毫秒数
	 * 
	 * @return 毫秒
	 */
	public static long getTimeInMillis() {
		return System.currentTimeMillis ();
	}
	/**
	 * 返回当前秒数
	 * 
	 * @return 秒
	 */
	public static Long getTimeInSecond() {
		return System.currentTimeMillis ()/1000;
	}

    /**
     * 返回当前时间加上sec秒后的时间串
     * @param startTime
     * @return yyyy-MM-dd HH:mm:ss
     */
	public static String getAddTime(int sec) {
		try {
			SimpleDateFormat sdf = new SimpleDateFormat(format);
			Calendar outTime = Calendar.getInstance();
            outTime.add(Calendar.SECOND, sec);
			return sdf.format(new Date(outTime.getTimeInMillis()));
		} catch (Exception e) {
			logger.error("",e);
		}
		return "";
	}
	
	/**
	 * 获取当前时间
	 * 
	 * @return
	 */
	public static String getCurrentTime() {
		String timeStr = "";

		int temp = 0;
		Calendar calendar = Calendar.getInstance();

		temp = calendar.get(Calendar.HOUR_OF_DAY);
		if (temp < 10) {
			timeStr += "0";
		}
		timeStr += temp + TIME_SPLIT_SIGN;

		temp = calendar.get(Calendar.MINUTE);
		if (temp < 10) {
			timeStr += "0";
		}
		timeStr += temp + TIME_SPLIT_SIGN;

		temp = calendar.get(Calendar.SECOND);
		if (temp < 10) {
			timeStr += "0";
		}
		timeStr += temp;

		return timeStr;
	}
   /**
    * 格式日期
    * @param date
    * @param dateformat
    * @return
    */
	public static String formatDate(Date date, String dateformat) {
		if (date == null)
			return "";
		SimpleDateFormat sf = new SimpleDateFormat(dateformat);
		return sf.format(date);
	}
    /**
     * 格式日期
     * @param datetime
     * @param dateformat
     * @return
     */
	public static Date getDate(String datetime, String dateformat) {
		if (datetime == null)
			return null;
		SimpleDateFormat sf = new SimpleDateFormat(dateformat);
		try {
			return sf.parse(datetime);
		} catch (ParseException e) {
			logger.error("", e);
			return new Date();
		}
	}
   
	/**
	 * 获取Date格式的日期信息 yyyy-MM-dd
	 * 
	 * @param date
	 *            日期（yyyy-MM-dd）
	 * 
	 * @return Date
	 */
	public static Date getDate(String date) {
		if (date == null)
			return null;
		else {
			try {
				SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
				return sdf.parse(date);
			} catch (Exception e) {
				logger.error("日期格式转换错误：", e);
				return null;
			}
		}
	}

	/**
	 * 获取Date格式的日期时间信息yyyy-MM-dd HH:mm:ss
	 * 
	 * @param dateTime
	 *            日期时间（yyyy-MM-dd HH:mm:ss）
	 * 
	 * @return Date
	 */
	public static Date getDateTime(String dateTime) {
		if (dateTime == null)
			return null;
		else {
			try {
				SimpleDateFormat sdf = new SimpleDateFormat(
						"yyyy-MM-dd HH:mm:ss");
				return sdf.parse(dateTime);
			} catch (Exception e) {
				logger.error("日期时间格式转换错误：", e);
				return null;
			}
		}
	}

	/**
	 * 将日期转化为 "yyyy-MM-dd HH:mm:ss" 类型字符串
	 * 
	 * @param dateTime
	 * 
	 * @return
	 */
	public static String getDateTimeStr(Object dateTime) {
		try {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

			return sdf.format(dateTime);
		} catch (Exception e) {
			logger.error("转化日期格式错误：", e);
			return null;
		}
	}
	/**
	 * 将日期转化为 "yyyy-MM-dd HH:mm" 类型字符串
	 * 
	 * @param dateTime
	 * 
	 * @return
	 */
	public static String getShortDateTimeStr(Object dateTime) {
		try {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");

			return sdf.format(dateTime);
		} catch (Exception e) {
			logger.error("转化日期格式错误：", e);
			return null;
		}
	}

	/**
	 * 将日期转化为 "yyyy-MM-dd" 类型字符串
	 * 
	 * @param dateTime
	 * 
	 * @return
	 */
	public static String getDateStr(Object dateTime) {
		try {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

			return sdf.format(dateTime);
		} catch (Exception e) {
			logger.error("转化日期格式错误：", e);
			return null;
		}
	}
   /**
    * HH:mm:ss
    * @param dateTime
    * @return
    */
	public static String getTimeStr(Object dateTime) {
		try {
			SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");

			return sdf.format(dateTime);
		} catch (Exception e) {
			logger.error("转化日期格式错误：", e);
			return null;
		}
	}

	public static String getTimeStr(Object dateTime, String format) {
		try {
			SimpleDateFormat sdf = new SimpleDateFormat(format);

			return sdf.format(dateTime);
		} catch (Exception e) {
			logger.error("转化日期格式错误：", e);
			return null;
		}
	}

	/**
	 * 将日期转化为 "yyyy-MM-dd HH:mm:ss" 类型字符串
	 * 
	 * @param dateTime
	 * 
	 * @return
	 */
	public static String getDateTime() {
		try {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

			return sdf.format(new Date());
		} catch (Exception e) {
			logger.error("转化日期格式错误：", e);
			return null;
		}
	}
	/**
	 * 将日期转化为 "yyyy-MM-dd HH:mm:ss" 类型字符串
	 * 
	 * @param dateTime
	 * 
	 * @return
	 */
	public static String getDateTime(Long time) {
		try {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

			return sdf.format(new Date(time));
		} catch (Exception e) {
			logger.error("转化日期格式错误：", e);
			return null;
		}
	}
	/**
	 * 比较日期大小
	 * 
	 * @param fromDate
	 *            开始日期（yyyy-MM-dd）
	 * @param toDate
	 *            结束日期（yyyy-MM-dd）
	 * 
	 * @return boolean false：日期参数为null；日期参数非法；起始日期大于结束日期。
	 *         true：日期格式正确，结束日期大于起始日期。
	 */
	public static boolean compareDate(String fromDate, String toDate) {
		if (fromDate == null || toDate == null)
			return false;

		try {
			// 时间字符串符合yyyy-MM-dd模式;
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			Date from = sdf.parse(fromDate);
			Date to = sdf.parse(toDate);

			if (from.getTime() > to.getTime())
				return false;
		} catch (Exception e) {
			logger.error("日期转换错误:", e);
			return false;
		}

		return true;
	}

	/**
	 * 比较2个日期时间的大小
	 * 
	 * @param from
	 *            起始日期时间
	 * @param to
	 *            结束日期时间
	 * 
	 * @return boolean true：日期时间格式有效 && 起始日期时间<=结束日期时间 false:日期时间格式无效 ||
	 *         起始日期时间>结束日期时间
	 */
	public static boolean compareDateTime(String from, String to) {
		try {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

			Date fromDateTime = sdf.parse(from);
			Date toDateTime = sdf.parse(to);

			if (fromDateTime.getTime() > toDateTime.getTime())
				return false;
		} catch (Exception e) {
			logger.error("日期时间格式错误：", e);
			return false;
		}

		return true;
	}

	/**
	 * * 比较2个日期时间的大小
	 * 
	 * @param from
	 *            起始日期时间
	 * @param to
	 *            结束日期时间
	 * 
	 * @return boolean true：日期时间格式有效 && 起始日期时间<=结束日期时间 false:日期时间格式无效 ||
	 *         起始日期时间>结束日期时间
	 */
	public static boolean compareDateTimeEQ(String from, String to) {
		try {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

			Date fromDateTime = sdf.parse(from);
			Date toDateTime = sdf.parse(to);

			if (fromDateTime.getTime() >= toDateTime.getTime())
				return false;
		} catch (Exception e) {
			logger.error("日期时间格式错误：", e);
			return false;
		}

		return true;
	}

	public static boolean compareDateTimeEQ(Date fromDateTime, Date toDateTime) {
		try {

			if (fromDateTime.getTime() >= toDateTime.getTime())
				return false;
		} catch (Exception e) {
			logger.error("日期时间格式错误：", e);
			return false;
		}

		return true;
	}

	/**
	 * 日期格式校验
	 * 
	 * @param date
	 *            日期（yyyy-MM-dd）
	 * @return boolean 校验成功返回true,否则返回false;
	 */
	public static boolean isDate(String date) {
		if (date == null)
			return false;

		try {
			// 时间字符串符合yyyy-MM-dd模式;
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			sdf.parse(date);

			return true;
		} catch (Exception e) {
			logger.error("日期格式校验错误：", e);
			return false;
		}
	}

	/**
	 * 日期时间格式校验
	 * 
	 * @param date
	 *            日期（yyyy-MM-dd HH:mm:ss）
	 * 
	 * @return boolean 校验成功返回true,否则返回false;
	 */
	public static boolean isDateTime(String dateTime) {
		if (dateTime == null)
			return false;

		try {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			sdf.parse(dateTime);

			return true;
		} catch (Exception e) {
			logger.error("日期时间格式校验错误：", e);
			return false;
		}
	}

	/**
	 * 得到某个日期所属月份的最大日期值；
	 * 
	 * @param date
	 *            String
	 * @return int
	 */
	public static int getMaxDayOfMonth(String date) {
		String[] mydate = date.split("-");

		GregorianCalendar gcal = new GregorianCalendar();
		gcal.set(Calendar.YEAR, Integer.parseInt(mydate[0]));
		gcal.set(Calendar.MONTH, Integer.parseInt(mydate[1]) - 1);
		gcal.set(Calendar.DAY_OF_MONTH, 1);
		return gcal.getActualMaximum(Calendar.DAY_OF_MONTH);
	}

	/**
	 * 获取指定日期的后N天日期信息
	 * 
	 * @param date
	 *            日期（yyyy-MM-dd）
	 * @param days
	 *            天数
	 * 
	 * @return String
	 */
	public static String afterDays(String date, int days) {
		return addDays(date, Math.abs(days));
	}

	/**
	 * 获取指定日期的前N天日期信息
	 * 
	 * @param date
	 *            日期（yyyy-MM-dd）
	 * @param days
	 *            天数
	 * 
	 * @return String
	 */
	public static String beforDays(String date, int days) {
		return addDays(date, 0 - Math.abs(days));
	}

	/**
	 * 获取指定日期的后N小时日期信息
	 * 
	 * @param date
	 *            日期（yyyy-MM-dd HH:mm:ss）
	 * @param hour
	 *            小时
	 * 
	 * @return String
	 */
	public static String afterHour(String date, int hour) {
		return addHour(date, Math.abs(hour));
	}

	/**
	 * 获取指定日期的前N分钟日期信息
	 * 
	 * @param date
	 *            日期（yyyy-MM-dd HH:mm:ss）
	 * @param minute
	 *            分钟
	 * 
	 * @return String
	 */
	public static String beforeMinute(String date, int minute) {
		return addMinute(date, -minute);
	}

	/**
	 * 获取指定日期的后N分钟日期信息
	 * 
	 * @param date
	 *            日期（yyyy-MM-dd HH:mm:ss）
	 * @param minute
	 *            分钟
	 * 
	 * @return String
	 */
	public static String afterMinute(String date, int minute) {
		return addMinute(date, Math.abs(minute));
	}

	/**
	 * 获取指定日期的前N分钟日期信息
	 * 
	 * @param date
	 *            日期（yyyy-MM-dd HH:mm:ss）
	 * @param minute
	 *            分钟
	 * 
	 * @return String
	 */
	public static String beforMinute(String date, int minute) {
		return addMinute(date, 0 - Math.abs(minute));
	}

	/**
	 * 获取指定日期的后N天日期信息
	 * 
	 * @param date
	 *            日期（yyyy-MM-dd）
	 * @param days
	 *            天数（-1表示减去相应的天数）
	 * 
	 * @return String
	 */
	private static String addDays(String date, int days) {
		// logger.debug("Enter addOneDayToCurrentDay()");
		String[] mydate = date.split("-");

		GregorianCalendar gcal = new GregorianCalendar();
		gcal.set(Calendar.YEAR, Integer.parseInt(mydate[0]));
		gcal.set(Calendar.MONTH, Integer.parseInt(mydate[1]) - 1);
		gcal.set(Calendar.DATE, Integer.parseInt(mydate[2]));
		gcal.add(Calendar.DATE, days);

		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		String addDate = sdf.format(gcal.getTime());

		// logger.debug("Exit addOneDayToCurrentDay()");
		return addDate;
	}

	/**
	 * 获取指定日期的后N天日期信息
	 * 
	 * @param date
	 *            日期（yyyy-MM-dd）
	 * @param minute
	 *            分钟（-1表示减去相应的天数）
	 * 
	 * @return String
	 */
	public static String addMinute(String date, int minute) {
		// logger.debug("Enter addOneDayToCurrentDay()");
		String[] mydate = date.split(" ")[0].split("-");

		GregorianCalendar gcal = new GregorianCalendar();
		gcal.set(Calendar.YEAR, Integer.parseInt(mydate[0]));
		gcal.set(Calendar.MONTH, Integer.parseInt(mydate[1]) - 1);
		gcal.set(Calendar.DATE, Integer.parseInt(mydate[2]));

		String[] time = date.split(" ")[1].split(":");
		gcal.set(Calendar.HOUR_OF_DAY, Integer.parseInt(time[0]));
		gcal.set(Calendar.MINUTE, Integer.parseInt(time[1]));
		gcal.set(Calendar.SECOND, Integer.parseInt(time[2]));

		gcal.add(Calendar.MINUTE, minute);

		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String addDate = sdf.format(gcal.getTime());

		// logger.debug("Exit addOneDayToCurrentDay()");
		return addDate;
	}

	/**
	 * 获取指定日期的后N小时日期信息
	 * 
	 * @param date
	 * @param hour
	 * @return
	 */
	public static String addHour(String date, int hour) {
		// logger.debug("Enter addOneDayToCurrentDay()");
		String[] mydate = date.split(" ")[0].split("-");

		GregorianCalendar gcal = new GregorianCalendar();
		gcal.set(Calendar.YEAR, Integer.parseInt(mydate[0]));
		gcal.set(Calendar.MONTH, Integer.parseInt(mydate[1]) - 1);
		gcal.set(Calendar.DATE, Integer.parseInt(mydate[2]));

		String[] time = date.split(" ")[1].split(":");
		gcal.set(Calendar.HOUR_OF_DAY, Integer.parseInt(time[0]));
		gcal.set(Calendar.MINUTE, Integer.parseInt(time[1]));
		gcal.set(Calendar.SECOND, Integer.parseInt(time[2]));

		gcal.add(Calendar.HOUR, hour);

		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String addDate = sdf.format(gcal.getTime());

		// logger.debug("Exit addOneDayToCurrentDay()");
		return addDate;
	}

	/**
	 * 获取指定 天数后的日期
	 * 
	 * @param date
	 * @param hour
	 * @return
	 */
	public static Date addDay(Date date, int day) {
		GregorianCalendar gcal = new GregorianCalendar();
		gcal.set(Calendar.YEAR, date.getYear());
		gcal.set(Calendar.MONTH, date.getMonth());
		gcal.set(Calendar.DATE, date.getDay());
		gcal.set(Calendar.HOUR, date.getHours());
		gcal.set(Calendar.MINUTE, date.getMinutes());
		gcal.set(Calendar.SECOND, date.getSeconds());
		gcal.add(Calendar.DATE, day);
		Date addDate = gcal.getTime();
		return addDate;
	}

	/**
	 * 获取指定日期时间增加N秒后的日期时间
	 * 
	 * @param dateTime
	 *            日期时间（yyyy-MM-dd HH:mm:ss）
	 * @param seconds
	 *            秒
	 * 
	 * @return String
	 */
	public static String addSeconds(String dateTime, int seconds) {
		if (isDateTime(dateTime)) {
			GregorianCalendar gcal = new GregorianCalendar();
			gcal.setTime(getDateTime(dateTime));
			gcal.add(Calendar.SECOND, seconds);

			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			return sdf.format(gcal.getTime());
		} else
			return null;
	}

	/**
	 * 获取指定日期时间增加N秒后的日期时间
	 * 
	 * @param dateTime
	 *            日期时间（yyyy-MM-dd HH:mm:ss）
	 * @param seconds
	 *            秒
	 * 
	 * @return Date （yyyy-MM-dd HH:mm:ss）
	 */
	public static Date addSeconds(Date dateTime, int seconds) {
		Date dateTimeAdd = null;

		try {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			String dateTimeStr = sdf.format(dateTime);

			if (isDateTime(dateTimeStr)) {
				GregorianCalendar gcal = new GregorianCalendar();
				gcal.setTime(dateTime);
				gcal.add(Calendar.SECOND, seconds);
				dateTimeAdd = sdf.parse(sdf.format(gcal.getTime()));
			} else
				dateTimeAdd = null;
		} catch (Exception e) {
			logger.error("日期秒数操作错误：", e);
		}

		return dateTimeAdd;
	}

	/**
	 * 获取指定日期对应的星期信息
	 * 
	 * @param date
	 *            String
	 * 
	 * @return int
	 */
	public static int getWeek(String date) {
		// logger.debug("Enter getWeekDayFromDate()");
		String[] mydate = date.split("-");

		GregorianCalendar gcal = new GregorianCalendar();
		gcal.set(Calendar.YEAR, Integer.parseInt(mydate[0]));
		gcal.set(Calendar.MONTH, Integer.parseInt(mydate[1]) - 1);
		gcal.set(Calendar.DATE, Integer.parseInt(mydate[2]));

		return gcal.get(Calendar.DAY_OF_WEEK);
	}

	/**
	 * 获取两个日期时间的间隔天数
	 * 
	 * @param from
	 *            起始日期时间(yyyy-MM-dd HH:mm:ss)
	 * @param to
	 *            结束日期时间(yyyy-MM-dd HH:mm:ss)
	 * 
	 * @return long 间隔天数(二者之差的绝对值)
	 */
	public static long getDays(String from, String to) {
		long days = -1;

		try {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			Date fromDateTime = sdf.parse(from);
			Date toDateTime = sdf.parse(to);
			// 毫秒转化为天数
			days = (toDateTime.getTime() - fromDateTime.getTime())
					/ (1000 * 60 * 60 * 24);

			// 不足一天按整一天算,比如今天与明天相差不是0天而是1天
			return Math.abs(days);
		} catch (Exception e) {
			logger.error("日期时间格式错误：", e);
			return days;
		}
	}

	/**
	 * 获取两个日期时间的间隔天数
	 * 
	 * @param from
	 *            起始日期时间(yyyy-MM-dd HH:mm:ss)
	 * @param to
	 *            结束日期时间(yyyy-MM-dd HH:mm:ss)
	 * 
	 * @return long 间隔天数(二者之差的绝对值)
	 */
	public static long getMinutes(String from, String to) {
		long minutes = -1;

		try {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			Date fromDateTime = sdf.parse(from);
			Date toDateTime = sdf.parse(to);
			// 毫秒转化为分钟
			minutes = (toDateTime.getTime() - fromDateTime.getTime())
					/ (1000 * 60);
			// 不足分钟按整一分钟算,
			return Math.abs(minutes);

		} catch (Exception e) {
			logger.error("日期时间格式错误：", e);
			return minutes;
		}
	}

	public static String transFormatDate(String dateTime) {

		String[] arr = dateTime.substring(0, 10).split("-");

		StringBuffer buf = new StringBuffer();

		for (int i = 0; i < arr.length; i++) {
			buf.append(arr[i]);
		}

		return buf.toString();
	}

	/**
	 * 将日期转化为需要格式如"yyyy-MM-dd" 格式类型字符串
	 * 
	 * @param dateTime
	 * 
	 * @return
	 */
	public static String getDateStr(Object dateTime, String format) {
		try {
			SimpleDateFormat sdf = new SimpleDateFormat(format);

			return sdf.format(dateTime);
		} catch (Exception e) {
			logger.error("转化日期格式错误：", e);
			return null;
		}
	}
	
	
	/**
	 * 判断订单或状态是否过期或完成.
	 * @param StartTime 毫秒
	 * @param requireTime 毫秒
	 * @return boolean ture 过期,了或者完成了
	 */
	public static boolean isOrderCompleteInMill(long StartTimeInMil , long requireTimeInMill)
	{
		long currentTime = System.currentTimeMillis();
		return (currentTime - StartTimeInMil - requireTimeInMill)>=0?true:false;
	}
	
	/**
	 * 判断订单或状态是否过期或完成.
	 * @param StartTime 秒
	 * @param requireTime 秒
	 * @return long long >0 未完成值为需要的时间, <0 完成
	 */
	public static Long getNeedTime(long StartTime , long requireTime)
	{
		long currentTime = DateUtil.getTimeInSecond();
		return StartTime + requireTime-currentTime ;
	}
	/**
	 * 得到现在距某时间点的毫秒时间
	 * 
	 * @param time
	 * @return
	 */
	public static Long getDelayTimeInMills(String hoursTime) {
		try {
			Date date = new Date();
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			StringBuffer dateStr = new StringBuffer();
			dateStr.append(DateUtil.getDateStr(date));
			dateStr.append(" " + hoursTime.trim());
			String dates = dateStr.toString();
			Date firstTime = sdf.parse(dates);
			if (firstTime.before(date)) {
				Calendar calendar = GregorianCalendar.getInstance();
				calendar.setTime(firstTime);
				calendar.add(Calendar.DATE, 1);
				firstTime = calendar.getTime();
			}
			long delay = firstTime.getTime() - System.currentTimeMillis();
			return delay;
		} catch (ParseException e) {
			logger.error("", e);
			return 0L;
		}
	}
	
	/**
	 * 获得传入时间的的当日0点时间
	 * 
	 * @param time
	 * @return
	 */
	public static Long getIntradayZero () {
		try {
			long wucha=8*60*60*1000;//误差时间 因为时间从1970-01-01 08:00:00
			long sytemtime=System.currentTimeMillis();//获取当前系统时间
			return (sytemtime/DateUtil.DAY)*DateUtil.DAY-wucha;
		} catch (Exception e) {
			logger.error("取出当天零点时间错误", e);
			return 0L;
		}
	}
	public static void main(String[] args){
//		System.out.println(DateUtil.getDateTime("2008-10-12 12:12:25").getSeconds());
//		NameValuePair rewq = new NameValuePair("account","dfsfds");
//		System.out.println(HTTPSend.send("http://192.168.1.9:8080/KDZZgame/onlineManager", new NameValuePair[]{rewq} ));
		
	}
	


}
